# 2串1信息分析
from loaddata import modelKJ as db
import pandas as pd
from analysis import util

def analysis(year,rang):
    ds = db.getHistoryDataFromYear(year)
    # 找到让一球，3场，转换数据格式{时间:[[赔，赔率，开奖结果],...]，
    sd = get_select_datas(ds,rang)
    #  转换成前端可以显示的数据
    return toXian(sd)

# 根据日期分组
def get_select_datas(ds,rang):
    rs = []
    # 找到让一球，并转换matchTime
    for m in ds:
        goalLine = m.get("base_info").get("goalLine")
        if goalLine == rang:
            m["matchTime"] = m.get("base_info").get("matchTime")
            rs.append(m)

    # 取出胜平负，让球胜平负开奖结果
    ds = to_KJ_Flag(rs)
    # 按照时间分组
    df = pd.DataFrame(ds)
    grouped_dicts = df.groupby('matchTime').apply(lambda x: x.to_dict('records')).to_dict()
    select_ds = {}
    for key in grouped_dicts:
        ts = grouped_dicts.get(key)
        if len(ts) >= 2:
            # 直接选第一场和第二场进去，后期也可以随机或指定
            select_ds[key] = [ts[-1],ts[-2]]
    return select_ds

# 开奖标记
def to_KJ_Flag(ds):
    rs = []
    for m in ds:
        mm = {}
        mm["base_info"] = m.get("base_info")
        mm["HAD"] = toHAD(m.get("kaij").get("HAD"))
        mm["HHAD"] = toHAD(m.get("kaij").get("HHAD"))
        mm["matchTime"] = m.get("base_info").get("matchTime")
        # 未开奖的数据，不要
        if mm.get("HAD"):
            rs.append(mm)
    return rs

def toHAD(had):
    r = []  # 构造一个[1,2.32,‘a’]  第一个是陪数，第二个事赔率，第三是开奖结果
    if had:
        combination = had.get("combination").lower()  # 开奖标记，要转换小写
        ps = had.get("ps")[-1]
        a = ps.get("a")
        d = ps.get("d")
        h = ps.get("h")
        spf = {"h": float(h), "d": float(d), "a": float(a)}
        peid_spf = util.to_pei_list(spf)
        # 找出赔数及开奖赔率
        for i in range(len(peid_spf)):
            if peid_spf[i][0] == combination:  # 说明开奖结果
                r.append(i+1)   # 第一个放赔数
                r.append(peid_spf[i][1])    # 第二个放赔率
                r.append(combination)  # 第三个开奖结果
                break
    return r

#   转换显示数据
def toXian(ds):

    # 格式：场次+a、b+赔数，a胜平负，b让球胜平负
    s1 = ['1a1', '1b1']
    s2 = ['2a1', '2b1']
    # 进行组合:['1a12a1','1a12a2',.....]
    c = []  # 存放组合
    for m in s1:
        for mm in s2:
                c.append(m + mm)

    # print(c)
    # 返回结果
    result = {"headd":c}
    #   存放每天的开奖，按照3串1的方式
    day_rs = []
    # 存放返回数据
    all_rs = []     # 格式 [['2024-10-22',[[1,2.32,‘a’],[1,2.32,‘a’]],[]]]   第一个时间，第二个胜平负和让球的结果，第三个统计的赔率结果，最后一行是全部数据的统计
    #  每天开奖数据进行翻译
    for dk in ds:
        # 构造一个空list存放每天返回的数据
        ars = [dk]  # 第一个放时间
        # 构造一个空list存放赔率,初始赔率0
        r = [0 for i in c]
        day = ds.get(dk)
        # 获取第一场
        ds1 = day[0]    # 获取出来的格式：{"HAD":[1,2.32,‘a’],"HHAD":[2,3.32,‘d’]}  第一个是陪数，第二个事赔率，第三是开奖结果h胜，d平，a负
        # 获取第二场
        ds2 = day[1]

        ars.append([ds1,ds2])    # 二个胜平负和让球的结果
        # 翻译a、b
        pei1s = [[str(1)+"a"+str(ds1.get("HAD")[0]),ds1.get("HAD")[1]],[str(1)+"b"+str(ds1.get("HHAD")[0]),ds1.get("HHAD")[1]]]  # 构造格式：场次+a、b+赔数，a胜平负，b让球胜平负
        pei2s = [[str(2)+"a"+str(ds2.get("HAD")[0]),ds2.get("HAD")[1]],[str(2)+"b"+str(ds2.get("HHAD")[0]),ds2.get("HHAD")[1]]]  # 构造格式：场次+a、b+赔数，a胜平负，b让球胜平负
        # 2串1组合
        for m in pei1s:
            for mm in pei2s:
                    #  找出显示数据的下标
                    fv = m[0] + mm[0]
                    pei_index = next((i for i, x in enumerate(c) if x == fv), None)
                    # 如果找到就放，找不到就不显示
                    if(pei_index is not None):
                        # 将赔率放入相应的下标下
                        r[pei_index] = round(mm[1] * m[1], 2)
        day_rs.append(r)
        ars.append(r)  # 第三个统计的赔率结果
        all_rs.append(ars)

    # 统计一下每一列的平均赔率，命中率[全平均赔率，中平均赔率，命中率]
    rs = [[0,0,0] for i in range(len(day_rs[0]))]
    for i in range(len(rs)):    # 有多少列
        zhong_total = 0
        peil_total = 0
        for m in day_rs:    # 每一天
            peil_total += m[i]
            if m[i]:
                # 表示红了，记录
                zhong_total +=1
        # 计算
        rs[i][0] = round(peil_total / len(day_rs), 2)
        rs[i][1] = round(peil_total / zhong_total, 2)
        rs[i][2] = round(zhong_total / len(day_rs), 2)

    # 按照时间排序
    sorted_list = sorted(all_rs, key=lambda x: x[0],reverse=True)
    result["all_rs"] = sorted_list
    result["tj"] = rs
    return result